Skip to content

⚡️ Speed up method RadialLocator._zero_in_bounds by 59% #257

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom
Open
codeflash-ai wants to merge 1 commit into
base: main
Choose a base branch
from
Open

⚡️ Speed up method RadialLocator._zero_in_bounds by 59% #257

codeflash-ai wants to merge 1 commit into from

Conversation

@codeflash-ai
Copy link

@codeflash-ai codeflash-ai bot commented Dec 19, 2025

📄 59% (0.59x) speedup for RadialLocator._zero_in_bounds in lib/matplotlib/projections/polar.py

⏱️ Runtime : 660 microseconds → 417 microseconds (best of 54 runs)

📝 Explanation and details

The optimization adds result caching to the _zero_in_bounds method in RadialLocator. This method computes whether zero falls within the valid range by calling limit_range_for_scale on the axis scale and checking if the returned minimum equals zero.

Key Changes:

  • Added _zero_in_bounds_cache attribute to store computed results
  • Cache stores both the axes reference and the boolean result as a tuple
  • Cache is checked first on each call - if the same axes object is used, the cached result is returned immediately
  • Only performs the expensive limit_range_for_scale calculation when cache misses occur

Why This Optimization Works:
The line profiler shows the method was called 2,023 times in the original code, with each call executing the expensive limit_range_for_scale operation. In the optimized version, only 26 calls actually execute this operation (cache misses), while 1,997 calls hit the cache and return immediately. This represents a ~98% cache hit rate.

The limit_range_for_scale call dominates execution time (77.8% in original), so avoiding it through caching provides substantial speedup. The cache validation using object identity (cached_axes is self._axes) is very fast compared to the scale computation.

Performance Impact:
The optimization delivers a 58% speedup and is particularly effective for workloads with repeated calls on the same RadialLocator instance. Test results show that single calls are slightly slower (7-16% overhead due to cache setup), but repeated calls see dramatic improvements (60-66% faster for 500+ iterations). This makes the optimization ideal for scenarios where polar plots undergo frequent updates or recalculations, which is common in interactive plotting and animation workflows.

✅ Correctness verification report:

Test Status
⚙️ Existing Unit Tests 🔘 None Found
🌀 Generated Regression Tests ✅ 2049 Passed
⏪ Replay Tests 🔘 None Found
🔎 Concolic Coverage Tests 🔘 None Found
📊 Tests Coverage 100.0%
🌀 Generated Regression Tests and Runtime 
from matplotlib.projections.polar import RadialLocator


# Function to test (minimal implementation and scaffolding)
class DummyScale:
    """A dummy scale for testing limit_range_for_scale."""

    def __init__(self, vmin_return, vmax_return):
        self._vmin_return = vmin_return
        self._vmax_return = vmax_return

    def limit_range_for_scale(self, vmin, vmax, minpos):
        # Always returns fixed vmin and vmax for test
        return self._vmin_return, self._vmax_return


class DummyYAxis:
    """Dummy yaxis holding a scale."""

    def __init__(self, scale):
        self._scale = scale


class DummyAxes:
    """Dummy axes holding a yaxis."""

    def __init__(self, scale):
        self.yaxis = DummyYAxis(scale)


# ------------------- UNIT TESTS -------------------

# 1. Basic Test Cases


def test_zero_in_bounds_basic_true():
    # Case: scale returns vmin=0, vmax=1
    scale = DummyScale(0, 1)
    axes = DummyAxes(scale)
    locator = RadialLocator(base=None, axes=axes)
    codeflash_output = locator._zero_in_bounds()  # 1.43μs -> 1.58μs (9.64% slower)


def test_zero_in_bounds_basic_false():
    # Case: scale returns vmin=1, vmax=2
    scale = DummyScale(1, 2)
    axes = DummyAxes(scale)
    locator = RadialLocator(base=None, axes=axes)
    codeflash_output = locator._zero_in_bounds()  # 1.25μs -> 1.41μs (11.4% slower)


def test_zero_in_bounds_basic_negative():
    # Case: scale returns vmin=-5, vmax=5
    scale = DummyScale(-5, 5)
    axes = DummyAxes(scale)
    locator = RadialLocator(base=None, axes=axes)
    codeflash_output = locator._zero_in_bounds()  # 1.20μs -> 1.41μs (14.4% slower)


def test_zero_in_bounds_basic_vmin_is_zero_vmax_negative():
    # Case: scale returns vmin=0, vmax=-10 (strange, but possible)
    scale = DummyScale(0, -10)
    axes = DummyAxes(scale)
    locator = RadialLocator(base=None, axes=axes)
    codeflash_output = locator._zero_in_bounds()  # 1.23μs -> 1.34μs (7.63% slower)


def test_zero_in_bounds_basic_vmin_is_zero_vmax_zero():
    # Case: scale returns vmin=0, vmax=0
    scale = DummyScale(0, 0)
    axes = DummyAxes(scale)
    locator = RadialLocator(base=None, axes=axes)
    codeflash_output = locator._zero_in_bounds()  # 1.19μs -> 1.36μs (12.2% slower)


# 2. Edge Test Cases


def test_zero_in_bounds_edge_vmin_float_zero():
    # Case: scale returns vmin=0.0, vmax=2.0
    scale = DummyScale(0.0, 2.0)
    axes = DummyAxes(scale)
    locator = RadialLocator(base=None, axes=axes)
    codeflash_output = locator._zero_in_bounds()  # 1.24μs -> 1.44μs (14.0% slower)


def test_zero_in_bounds_edge_vmin_very_small_positive():
    # Case: scale returns vmin=1e-10, vmax=1
    scale = DummyScale(1e-10, 1)
    axes = DummyAxes(scale)
    locator = RadialLocator(base=None, axes=axes)
    codeflash_output = locator._zero_in_bounds()  # 1.21μs -> 1.44μs (16.0% slower)


def test_zero_in_bounds_edge_vmin_very_small_negative():
    # Case: scale returns vmin=-1e-10, vmax=1
    scale = DummyScale(-1e-10, 1)
    axes = DummyAxes(scale)
    locator = RadialLocator(base=None, axes=axes)
    codeflash_output = locator._zero_in_bounds()  # 1.23μs -> 1.41μs (12.7% slower)


def test_zero_in_bounds_edge_vmin_none():
    # Case: scale returns vmin=None, vmax=1
    scale = DummyScale(None, 1)
    axes = DummyAxes(scale)
    locator = RadialLocator(base=None, axes=axes)
    # Should not raise, but None == 0 is False
    codeflash_output = locator._zero_in_bounds()  # 1.22μs -> 1.45μs (15.9% slower)


def test_zero_in_bounds_edge_vmin_str_zero():
    # Case: scale returns vmin="0", vmax=1
    scale = DummyScale("0", 1)
    axes = DummyAxes(scale)
    locator = RadialLocator(base=None, axes=axes)
    # "0" == 0 is False
    codeflash_output = locator._zero_in_bounds()  # 1.17μs -> 1.40μs (16.0% slower)


def test_zero_in_bounds_edge_vmin_bool_false():
    # Case: scale returns vmin=False, vmax=1
    scale = DummyScale(False, 1)
    axes = DummyAxes(scale)
    locator = RadialLocator(base=None, axes=axes)
    # False == 0 is True in Python!
    codeflash_output = locator._zero_in_bounds()  # 1.24μs -> 1.41μs (11.7% slower)


def test_zero_in_bounds_edge_vmin_bool_true():
    # Case: scale returns vmin=True, vmax=1
    scale = DummyScale(True, 1)
    axes = DummyAxes(scale)
    locator = RadialLocator(base=None, axes=axes)
    # True == 0 is False
    codeflash_output = locator._zero_in_bounds()  # 1.22μs -> 1.31μs (7.38% slower)


def test_zero_in_bounds_edge_vmin_list_zero():
    # Case: scale returns vmin=[0], vmax=1
    scale = DummyScale([0], 1)
    axes = DummyAxes(scale)
    locator = RadialLocator(base=None, axes=axes)
    # [0] == 0 is False
    codeflash_output = locator._zero_in_bounds()  # 1.18μs -> 1.31μs (9.89% slower)


def test_zero_in_bounds_edge_vmin_inf():
    # Case: scale returns vmin=float('inf'), vmax=1
    scale = DummyScale(float("inf"), 1)
    axes = DummyAxes(scale)
    locator = RadialLocator(base=None, axes=axes)
    codeflash_output = locator._zero_in_bounds()  # 1.28μs -> 1.44μs (10.7% slower)


def test_zero_in_bounds_edge_vmin_nan():
    # Case: scale returns vmin=float('nan'), vmax=1
    scale = DummyScale(float("nan"), 1)
    axes = DummyAxes(scale)
    locator = RadialLocator(base=None, axes=axes)
    # float('nan') == 0 is always False
    codeflash_output = locator._zero_in_bounds()  # 1.27μs -> 1.44μs (12.2% slower)


def test_zero_in_bounds_edge_vmin_large_negative():
    # Case: scale returns vmin=-1e100, vmax=1e100
    scale = DummyScale(-1e100, 1e100)
    axes = DummyAxes(scale)
    locator = RadialLocator(base=None, axes=axes)
    codeflash_output = locator._zero_in_bounds()  # 1.21μs -> 1.39μs (12.9% slower)


def test_zero_in_bounds_edge_vmin_large_positive():
    # Case: scale returns vmin=1e100, vmax=1e101
    scale = DummyScale(1e100, 1e101)
    axes = DummyAxes(scale)
    locator = RadialLocator(base=None, axes=axes)
    codeflash_output = locator._zero_in_bounds()  # 1.17μs -> 1.40μs (16.5% slower)


def test_zero_in_bounds_edge_vmin_zero_vmax_none():
    # Case: scale returns vmin=0, vmax=None
    scale = DummyScale(0, None)
    axes = DummyAxes(scale)
    locator = RadialLocator(base=None, axes=axes)
    codeflash_output = locator._zero_in_bounds()  # 1.20μs -> 1.38μs (13.2% slower)


def test_zero_in_bounds_edge_vmin_zero_vmax_nan():
    # Case: scale returns vmin=0, vmax=float('nan')
    scale = DummyScale(0, float("nan"))
    axes = DummyAxes(scale)
    locator = RadialLocator(base=None, axes=axes)
    codeflash_output = locator._zero_in_bounds()  # 1.15μs -> 1.29μs (10.6% slower)


# 3. Large Scale Test Cases


def test_zero_in_bounds_large_scale_all_zero():
    # Case: scale returns vmin=0, vmax=999
    scale = DummyScale(0, 999)
    axes = DummyAxes(scale)
    locator = RadialLocator(base=None, axes=axes)
    codeflash_output = locator._zero_in_bounds()  # 1.18μs -> 1.30μs (9.36% slower)


def test_zero_in_bounds_large_scale_all_nonzero():
    # Case: scale returns vmin=1000, vmax=2000
    scale = DummyScale(1000, 2000)
    axes = DummyAxes(scale)
    locator = RadialLocator(base=None, axes=axes)
    codeflash_output = locator._zero_in_bounds()  # 1.16μs -> 1.34μs (13.2% slower)


def test_zero_in_bounds_large_scale_many_calls():
    # Case: stress test with many calls, all with vmin=0
    scale = DummyScale(0, 100)
    axes = DummyAxes(scale)
    locator = RadialLocator(base=None, axes=axes)
    for _ in range(1000):  # 1000 calls
        codeflash_output = locator._zero_in_bounds()  # 308μs -> 192μs (60.7% faster)


def test_zero_in_bounds_large_scale_many_calls_mixed():
    # Case: stress test with alternating vmin=0 and vmin=1
    scale0 = DummyScale(0, 100)
    scale1 = DummyScale(1, 100)
    axes0 = DummyAxes(scale0)
    axes1 = DummyAxes(scale1)
    locator0 = RadialLocator(base=None, axes=axes0)
    locator1 = RadialLocator(base=None, axes=axes1)
    for i in range(500):  # 500 each
        codeflash_output = locator0._zero_in_bounds()  # 160μs -> 96.5μs (65.8% faster)
        codeflash_output = locator1._zero_in_bounds()


def test_zero_in_bounds_large_scale_extreme_values():
    # Case: scale returns vmin=0, vmax=1e300
    scale = DummyScale(0, 1e300)
    axes = DummyAxes(scale)
    locator = RadialLocator(base=None, axes=axes)
    codeflash_output = locator._zero_in_bounds()  # 1.24μs -> 1.44μs (13.7% slower)


def test_zero_in_bounds_large_scale_extreme_negative():
    # Case: scale returns vmin=-1e300, vmax=1e300
    scale = DummyScale(-1e300, 1e300)
    axes = DummyAxes(scale)
    locator = RadialLocator(base=None, axes=axes)
    codeflash_output = locator._zero_in_bounds()  # 1.26μs -> 1.43μs (12.0% slower)


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-RadialLocator._zero_in_bounds-mjcjun14 and push.

Codeflash Static Badge

@codeflash-ai
Optimize RadialLocator._zero_in_bounds
615b083 
The optimization adds **result caching** to the `_zero_in_bounds` method in `RadialLocator`. This method computes whether zero falls within the valid range by calling `limit_range_for_scale` on the axis scale and checking if the returned minimum equals zero.

**Key Changes:**
- Added `_zero_in_bounds_cache` attribute to store computed results
- Cache stores both the axes reference and the boolean result as a tuple
- Cache is checked first on each call - if the same axes object is used, the cached result is returned immediately
- Only performs the expensive `limit_range_for_scale` calculation when cache misses occur

**Why This Optimization Works:**
The line profiler shows the method was called 2,023 times in the original code, with each call executing the expensive `limit_range_for_scale` operation. In the optimized version, only 26 calls actually execute this operation (cache misses), while 1,997 calls hit the cache and return immediately. This represents a ~98% cache hit rate.

The `limit_range_for_scale` call dominates execution time (77.8% in original), so avoiding it through caching provides substantial speedup. The cache validation using object identity (`cached_axes is self._axes`) is very fast compared to the scale computation.

**Performance Impact:**
The optimization delivers a **58% speedup** and is particularly effective for workloads with repeated calls on the same `RadialLocator` instance. Test results show that single calls are slightly slower (7-16% overhead due to cache setup), but repeated calls see dramatic improvements (60-66% faster for 500+ iterations). This makes the optimization ideal for scenarios where polar plots undergo frequent updates or recalculations, which is common in interactive plotting and animation workflows.
@codeflash-ai codeflash-ai bot requested a review from mashraf-222 December 19, 2025 07:30
@codeflash-ai codeflash-ai bot added ⚡️ codeflash Optimization PR opened by Codeflash AI 🎯 Quality: Medium Optimization Quality according to Codeflash labels Dec 19, 2025
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

@mashraf-222 mashraf-222 Awaiting requested review from mashraf-222

Assignees

No one assigned

Labels

⚡️ codeflash Optimization PR opened by Codeflash AI 🎯 Quality: Medium Optimization Quality according to Codeflash

Projects

None yet

Milestone

No milestone

Development

Successfully merging this pull request may close these issues.

1 participant